755 research outputs found
Complete and efficient methods for supporting side effects in independent/restricted and-parallelism
It has been shown that it is possible to exploit Independent/Restricted And-parallelism in logic programs while retaining the conventional "don't know" semantics of such programs. In particular, it is possible to parallelize
pure Prolog programs while maintaining the semantics of the
language. However, when builtin side-effects (such as write or assert) appear in the program, if an identical observable behaviour to that of sequential Prolog implementations is to be preserved, such side-effects have
to be properly sequenced. Previously proposed solutions to this problem are either incomplete (lacking, for example, backtracking semantics) or they force sequentialization of significant portions of the execution graph which could otherwise run in parallel. In this paper a series of side-effect synchronization methods are proposed which incur lower overhead and allow more parallelism than those previously proposed. Most importantly, and unlike previous proposals, they have well-defined backward execution behaviour and require only a small modification to a given
(And-parallel) Prolog implementation
Polymers pushing Polymers: Polymer Mixtures in Thermodynamic Equilibrium with a Pore
We investigate polymer partitioning from polymer mixtures into nanometer size
cavities by formulating an equation of state for a binary polymer mixture
assuming that only one (smaller) of the two polymer components can penetrate
the cavity. Deriving the partitioning equilibrium equations and solving them
numerically allows us to introduce the concept of "polymers-pushing-polymers"
for the action of non-penetrating polymers on the partitioning of the
penetrating polymers. Polymer partitioning into a pore even within a very
simple model of a binary polymer mixture is shown to depend in a complicated
way on the composition of the polymer mixture and/or the pore-penetration
penalty. This can lead to enhanced as well as diminished partitioning, due to
two separate energy scales that we analyse in detail.Comment: 10 pages, 6 figure
On the evaluation of matrix elements in partially projected wave functions
We generalize the Gutzwiller approximation scheme to the calculation of
nontrivial matrix elements between the ground state and excited states. In our
scheme, the normalization of the Gutzwiller wave function relative to a
partially projected wave function with a single non projected site (the
reservoir site) plays a key role. For the Gutzwiller projected Fermi sea, we
evaluate the relative normalization both analytically and by variational
Monte-Carlo (VMC). We also report VMC results for projected superconducting
states that show novel oscillations in the hole density near the reservoir
site
The CDG, UDG, and MEL methods for automatic compile-time parallelization of logic programs for independent and-parallelism
There has been significant interest in parallel execution models for logic programs which exploit Independent And-Parallelism (IAP). In these models, it is necessary to determine which goals are independent and therefore eligible
for parallel execution and which goals have to wait for which others during execution. Although this can be done at run-time, it can imply a very heavy overhead. In this paper, we present three algorithms for automatic compiletime
parallelization of logic programs using IAP. This is done by converting a clause into a graph-based computational form and then transforming this graph into linear expressions based on &-Prolog, a language for IAP. We also present an algorithm which, given a clause, determines if there is any loss of parallelism due to linearization, for the case in which only unconditional parallelism is desired. Finally, the performance of these annotation algorithms is discussed for some benchmark programs
Deriving a fixpoint computation algorithm for top-down abstract interpretation of logic programs
Bruynooghe described a framework for the top-down abstract interpretation of logic programs. In this framework, abstract interpretation is carried out by constructing an abstract and-or tree in a top-down fashion for a given query and program. Such an abstract interpreter requires fixpoint computation for programs which contain recursive predicates. This paper presents in detail a fixpoint algorithm that has been developed for this purpose and the motivation behind it. We start off by describing a simple-minded algorithm. After pointing out its shortcomings, we present a series of refinements to this algorithm, until we reach the final version. The aim is to give an intuitive grasp and provide justification for the relative complexity of the final algorithm. We also present an informal proof of correctness of the algorithm and some results obtained from an implementation
Determination of variable dependence information through abstract interpretation
Traditional schemes for abstract interpretation-based global analysis of logic programs generally focus on obtaining procedure argument mode and type information. Variable sharing information is often given only the attention needed to preserve the correctness of the analysis. However, such sharing information can be very useful. In particular, it can be used for predicting run-time goal independence, which can eliminate costly run-time checks in and-parallel execution. In this paper, a new algorithm for doing abstract interpretation in logic programs is described which infers the dependencies of the terms bound to program variables with increased precisión and at all points in the execution of the program, rather than just at a procedure level. Algorithms are presented for computing abstract entry and success substitutions
which extensively keep track of variable aliasing and term dependence information. The algorithms are illustrated with examples
- …